home *** CD-ROM | disk | FTP | other *** search
/ Mac Easy 2010 May / Mac Life Ubuntu.iso / casper / filesystem.squashfs / usr / lib / python2.6 / dist-packages / LanguageSelector / gtk / GtkLanguageSelector.pyc (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2009-10-12  |  30.4 KB  |  820 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.6)
  3.  
  4. import pygtk
  5. pygtk.require('2.0')
  6. import gtk
  7. import gtk.gdk as gtk
  8. import gtk.glade as gtk
  9. import pango
  10. import gobject
  11. import os.path as os
  12. import string
  13. import warnings
  14. warnings.filterwarnings('ignore', 'apt API not stable yet', FutureWarning)
  15. import apt
  16. import apt_pkg
  17. import os.path as os
  18. import shutil
  19. import subprocess
  20. import thread
  21. import time
  22. import gettext
  23. import sys
  24. import tempfile
  25. import pwd
  26. import grp
  27. import os
  28. from gettext import gettext as _
  29. (LIST_LANG, LIST_LANG_INFO) = range(2)
  30. (COMBO_LANGUAGE, COMBO_CODE) = range(2)
  31. from LanguageSelector.gtk.SimpleGladeApp import SimpleGladeApp
  32. from LanguageSelector.LocaleInfo import LocaleInfo
  33. from LanguageSelector.LanguageSelector import *
  34. from LanguageSelector.ImSwitch import ImSwitch
  35.  
  36. def xor(a, b):
  37.     ''' helper to simplify the reading '''
  38.     return a ^ b
  39.  
  40.  
  41. def blockSignals(f):
  42.     ''' decorator to ensure that the signals are blocked '''
  43.     
  44.     def wrapper(*args, **kwargs):
  45.         args[0]._blockSignals = True
  46.         res = f(*args, **kwargs)
  47.         args[0]._blockSignals = False
  48.         return res
  49.  
  50.     return wrapper
  51.  
  52.  
  53. def honorBlockedSignals(f):
  54.     ''' decorator to ensure that the signals are blocked '''
  55.     
  56.     def wrapper(*args, **kwargs):
  57.         if args[0]._blockSignals:
  58.             return None
  59.         res = f(*args, **kwargs)
  60.         return res
  61.  
  62.     return wrapper
  63.  
  64.  
  65. def insensitive(f):
  66.     """
  67.     decorator to ensure that a given function is run insensitive
  68.     warning: this will not stack well so don't use it for nested
  69.     stuff (a @insensitive func calling a @insensitve one)
  70.     """
  71.     
  72.     def wrapper(*args, **kwargs):
  73.         args[0].setSensitive(False)
  74.         res = f(*args, **kwargs)
  75.         args[0].setSensitive(True)
  76.  
  77.     return wrapper
  78.  
  79. STEPS_UPDATE_CACHE = [
  80.     33,
  81.     66,
  82.     100]
  83.  
  84. class GtkProgress(apt.OpProgress):
  85.     
  86.     def __init__(self, host_window, progressbar, parent, steps = STEPS_UPDATE_CACHE):
  87.         self.steps = steps[:]
  88.         self.base = 0
  89.         self.old = 0
  90.         self.next = int(self.steps.pop(0))
  91.         self._parent = parent
  92.         self._window = host_window
  93.         self._progressbar = progressbar
  94.         self._window.realize()
  95.         host_window.window.set_functions(gtk.gdk.FUNC_MOVE)
  96.         self._window.set_transient_for(parent)
  97.  
  98.     
  99.     def update(self, percent):
  100.         self._window.show()
  101.         self._parent.set_sensitive(False)
  102.         if self.old > percent:
  103.             self.base = self.next
  104.             
  105.             try:
  106.                 self.next = int(self.steps.pop(0))
  107.  
  108.         
  109.         progress = self.base + (percent / 100) * (self.next - self.base)
  110.         self.old = percent
  111.         self._progressbar.set_fraction(progress / 100)
  112.         while gtk.events_pending():
  113.             gtk.main_iteration()
  114.  
  115.     
  116.     def done(self):
  117.         self._parent.set_sensitive(True)
  118.  
  119.     
  120.     def hide(self):
  121.         self._window.hide()
  122.  
  123.  
  124.  
  125. class GtkLanguageSelector(LanguageSelectorBase, SimpleGladeApp):
  126.     
  127.     def __init__(self, datadir, options):
  128.         LanguageSelectorBase.__init__(self, datadir)
  129.         SimpleGladeApp.__init__(self, datadir + '/data/LanguageSelector.glade', domain = 'language-selector')
  130.         self.is_admin = grp.getgrnam('admin')[2] in os.getgroups()
  131.         self.has_other_users = False
  132.         num = 0
  133.         for l in pwd.getpwall():
  134.             if l.pw_uid >= 500 and l.pw_uid < 65534:
  135.                 num += 1
  136.             
  137.             if num >= 2:
  138.                 self.has_other_users = True
  139.                 break
  140.                 continue
  141.         
  142.         combo = self.combobox_system_language
  143.         model = gtk.ListStore(gobject.TYPE_STRING, gobject.TYPE_STRING)
  144.         cell = gtk.CellRendererText()
  145.         combo.pack_start(cell, True)
  146.         combo.add_attribute(cell, 'text', COMBO_LANGUAGE)
  147.         combo.set_model(model)
  148.         self.combo_syslang_dirty = False
  149.         combo = self.combobox_user_language
  150.         model = gtk.ListStore(gobject.TYPE_STRING, gobject.TYPE_STRING)
  151.         cell = gtk.CellRendererText()
  152.         combo.pack_start(cell, True)
  153.         combo.add_attribute(cell, 'text', COMBO_LANGUAGE)
  154.         combo.set_model(model)
  155.         self.combo_userlang_dirty = False
  156.         self.imSwitch = ImSwitch()
  157.         self.options = options
  158.         self._blockSignals = False
  159.         self.setupTreeView()
  160.         self.updateLanguageView()
  161.         self.updateUserDefaultCombo()
  162.         self.updateSystemDefaultCombo()
  163.         self.check_input_methods()
  164.         self.updateSyncButton()
  165.         self.button_apply.set_sensitive(False)
  166.         self.window_main.show()
  167.         self.setSensitive(False)
  168.         if not self._cache.havePackageLists:
  169.             d = gtk.MessageDialog(parent = self.window_main, flags = gtk.DIALOG_MODAL, type = gtk.MESSAGE_INFO, buttons = gtk.BUTTONS_CANCEL)
  170.             d.set_markup('<big><b>%s</b></big>\n\n%s' % (_('No language information available'), _('The system does not have information about the available languages yet. Do you want to perform a network update to get them now? ')))
  171.             d.set_title = ''
  172.             d.add_button(_('_Update'), gtk.RESPONSE_YES)
  173.             res = d.run()
  174.             d.destroy()
  175.             if res == gtk.RESPONSE_YES:
  176.                 self.setSensitive(False)
  177.                 self.update()
  178.                 self.updateLanguageView()
  179.                 self.setSensitive(True)
  180.             
  181.         
  182.         if self.options.verify_installed:
  183.             self.verifyInstalledLangPacks()
  184.         
  185.         if not self.imSwitch.available():
  186.             self.checkbutton_enable_input_methods.set_sensitive(False)
  187.         
  188.         self.setSensitive(True)
  189.  
  190.     
  191.     def setSensitive(self, value):
  192.         if value:
  193.             self.window_main.set_sensitive(True)
  194.             self.window_main.window.set_cursor(None)
  195.         else:
  196.             self.window_main.set_sensitive(False)
  197.             self.window_main.window.set_cursor(gtk.gdk.Cursor(gtk.gdk.WATCH))
  198.         while gtk.events_pending():
  199.             gtk.main_iteration()
  200.  
  201.     
  202.     def runAsRoot(self, userCmd):
  203.         ''' run the given command as root using gksu '''
  204.         cmd = [
  205.             '/usr/bin/gksu',
  206.             '--desktop',
  207.             '/usr/share/applications/language-selector.desktop',
  208.             '--']
  209.         ret = subprocess.call(cmd + userCmd)
  210.         return ret == 0
  211.  
  212.     
  213.     def updateSyncButton(self):
  214.         ''' check if the sync languages button should be enabled or not '''
  215.         button = self.checkbutton_sync_languages
  216.         combo = self.combobox_system_language
  217.         if self.is_admin == False:
  218.             button.set_active(False)
  219.             button.set_sensitive(False)
  220.             combo.set_sensitive(False)
  221.             return None
  222.         button.set_sensitive(True)
  223.         combo.set_sensitive(True)
  224.         userlang = self.combobox_user_language.get_active()
  225.         systemlang = self.combobox_system_language.get_active()
  226.         if not (self.has_other_users) and userlang == systemlang:
  227.             button.set_active(True)
  228.         else:
  229.             button.set_active(False)
  230.  
  231.     updateSyncButton = blockSignals(updateSyncButton)
  232.     
  233.     def setupTreeView(self):
  234.         ''' do all the treeview setup here '''
  235.         
  236.         def toggle_cell_func(column, cell, model, iter):
  237.             langInfo = model.get_value(iter, LIST_LANG_INFO)
  238.             inconsistent = langInfo.inconsistent
  239.             cell.set_property('active', langInfo.fullInstalled)
  240.             cell.set_property('inconsistent', inconsistent)
  241.  
  242.         
  243.         def lang_view_func(cell_layout, renderer, model, iter):
  244.             langInfo = model.get_value(iter, LIST_LANG_INFO)
  245.             inconsistent = langInfo.inconsistent
  246.             if langInfo.changes:
  247.                 markup = '<b>%s</b>' % langInfo.language
  248.             else:
  249.                 markup = '%s' % langInfo.language
  250.             renderer.set_property('markup', markup)
  251.  
  252.         renderer = gtk.CellRendererText()
  253.         column = gtk.TreeViewColumn(_('Language'), renderer, text = LIST_LANG)
  254.         column.set_property('expand', True)
  255.         column.set_cell_data_func(renderer, lang_view_func)
  256.         self.treeview_languages.append_column(column)
  257.         renderer = gtk.CellRendererToggle()
  258.         renderer.connect('toggled', self.on_toggled)
  259.         column = gtk.TreeViewColumn(_('Installed'), renderer)
  260.         column.set_cell_data_func(renderer, toggle_cell_func)
  261.         self.treeview_languages.append_column(column)
  262.         self._langlist = gtk.ListStore(str, gobject.TYPE_PYOBJECT)
  263.         self.treeview_languages.set_model(self._langlist)
  264.  
  265.     
  266.     def _get_langinfo_on_cursor(self):
  267.         (path, column) = self.treeview_languages.get_cursor()
  268.         if not path:
  269.             return None
  270.         iter = self._langlist.get_iter(path)
  271.         langInfo = self._langlist.get_value(iter, LIST_LANG_INFO)
  272.         return langInfo
  273.  
  274.     
  275.     def on_checkbutton_fonts_clicked(self, button):
  276.         if self.block_toggle:
  277.             return None
  278.         langInfo = self._get_langinfo_on_cursor()
  279.         langInfo.languagePkgList['languageSupportFonts'].doChange = not (langInfo.languagePkgList['languageSupportFonts'].doChange)
  280.         self.check_status()
  281.         self.treeview_languages.queue_draw()
  282.  
  283.     
  284.     def on_checkbutton_input_methods_clicked(self, button):
  285.         if self.block_toggle:
  286.             return None
  287.         langInfo = self._get_langinfo_on_cursor()
  288.         langInfo.languagePkgList['languageSupportInputMethods'].doChange = not (langInfo.languagePkgList['languageSupportInputMethods'].doChange)
  289.         self.check_status()
  290.         self.treeview_languages.queue_draw()
  291.  
  292.     
  293.     def on_checkbutton_writing_aids_clicked(self, button):
  294.         if self.block_toggle:
  295.             return None
  296.         langInfo = self._get_langinfo_on_cursor()
  297.         langInfo.languagePkgList['languageSupportWritingAids'].doChange = not (langInfo.languagePkgList['languageSupportWritingAids'].doChange)
  298.         self.check_status()
  299.         self.treeview_languages.queue_draw()
  300.  
  301.     
  302.     def on_checkbutton_basic_translations_clicked(self, button):
  303.         if self.block_toggle:
  304.             return None
  305.         langInfo = self._get_langinfo_on_cursor()
  306.         langInfo.languagePkgList['languagePack'].doChange = not (langInfo.languagePkgList['languagePack'].doChange)
  307.         self.check_status()
  308.         self.treeview_languages.queue_draw()
  309.  
  310.     
  311.     def on_checkbutton_extra_translations_clicked(self, button):
  312.         if self.block_toggle:
  313.             return None
  314.         langInfo = self._get_langinfo_on_cursor()
  315.         langInfo.languagePkgList['languageSupportTranslations'].doChange = not (langInfo.languagePkgList['languageSupportTranslations'].doChange)
  316.         self.check_status()
  317.         self.treeview_languages.queue_draw()
  318.  
  319.     
  320.     def on_checkbutton_extra_clicked(self, button):
  321.         if self.block_toggle:
  322.             return None
  323.         langInfo = self._get_langinfo_on_cursor()
  324.         langInfo.languagePkgList['languageSupportExtra'].doChange = not (langInfo.languagePkgList['languageSupportExtra'].doChange)
  325.         self.check_status()
  326.         self.treeview_languages.queue_draw()
  327.  
  328.     
  329.     def on_toggled(self, renderer, path_string):
  330.         ''' called when on install toggle '''
  331.         iter = self._langlist.get_iter_from_string(path_string)
  332.         langInfo = self._langlist.get_value(iter, LIST_LANG_INFO)
  333.         if langInfo.inconsistent:
  334.             for pkg in langInfo.languagePkgList.values():
  335.                 if pkg.available and not (pkg.installed):
  336.                     pkg.doChange = True
  337.                     continue
  338.             
  339.         elif langInfo.fullInstalled:
  340.             for pkg in langInfo.languagePkgList.values():
  341.                 if pkg.available:
  342.                     if not (pkg.installed) and pkg.doChange:
  343.                         pkg.doChange = False
  344.                     elif pkg.installed and not (pkg.doChange):
  345.                         pkg.doChange = True
  346.                     
  347.                 not (pkg.doChange)
  348.             
  349.         else:
  350.             for pkg in langInfo.languagePkgList.values():
  351.                 if pkg.available:
  352.                     if pkg.installed and pkg.doChange:
  353.                         pkg.doChange = False
  354.                     elif not (pkg.installed) and not (pkg.doChange):
  355.                         pkg.doChange = True
  356.                     
  357.                 not (pkg.doChange)
  358.             
  359.         self.check_status()
  360.         self.treeview_languages.queue_draw()
  361.  
  362.     
  363.     def on_treeview_languages_cursor_changed(self, treeview):
  364.         langInfo = self._get_langinfo_on_cursor()
  365.         for button, attr in (('checkbutton_basic_translations', langInfo.languagePkgList['languagePack']), ('checkbutton_extra_translations', langInfo.languagePkgList['languageSupportTranslations']), ('checkbutton_writing_aids', langInfo.languagePkgList['languageSupportWritingAids']), ('checkbutton_input_methods', langInfo.languagePkgList['languageSupportInputMethods']), ('checkbutton_extra', langInfo.languagePkgList['languageSupportExtra']), ('checkbutton_fonts', langInfo.languagePkgList['languageSupportFonts'])):
  366.             self.block_toggle = True
  367.             if (attr.installed or not (attr.doChange) or not (attr.installed)) and attr.doChange:
  368.                 getattr(self, button).set_active(True)
  369.             else:
  370.                 getattr(self, button).set_active(False)
  371.             getattr(self, button).set_sensitive(attr.available)
  372.             self.block_toggle = False
  373.         
  374.  
  375.     
  376.     def on_button_install_remove_languages_clicked(self, widget):
  377.         self.window_installer.show()
  378.  
  379.     
  380.     def debug_pkg_status(self):
  381.         langInfo = self._get_langinfo_on_cursor()
  382.         for pkg in langInfo.languagePkgList.items():
  383.             print '%s, available: %s, installed: %s, doChange: %s' % (pkg[0], pkg[1].available, pkg[1].installed, pkg[1].doChange)
  384.         
  385.         print 'inconsistent? : %s' % langInfo.inconsistent
  386.  
  387.     
  388.     def check_status(self):
  389.         changed = False
  390.         countInstall = 0
  391.         countRemove = 0
  392.         for lang, langInfo in self._langlist:
  393.             if langInfo.changes:
  394.                 changed = True
  395.                 for item in langInfo.languagePkgList.values():
  396.                     if item.doChange:
  397.                         if item.installed:
  398.                             countRemove = countRemove + 1
  399.                         else:
  400.                             countInstall = countInstall + 1
  401.                     item.installed
  402.                 
  403.         
  404.         textInstall = gettext.ngettext('%d to install', '%d to install', countInstall) % countInstall
  405.         textRemove = gettext.ngettext('%d to remove', '%d to remove', countRemove) % countRemove
  406.         if countRemove == 0 and countInstall == 0:
  407.             self.label_install_remove.set_text('')
  408.         elif countRemove == 0:
  409.             self.label_install_remove.set_text(textInstall)
  410.         elif countInstall == 0:
  411.             self.label_install_remove.set_text(textRemove)
  412.         else:
  413.             self.label_install_remove.set_text(_('%s, %s') % (textInstall, textRemove))
  414.         if changed:
  415.             self.button_apply.set_sensitive(True)
  416.         else:
  417.             self.button_apply.set_sensitive(False)
  418.  
  419.     
  420.     def on_combobox_system_language_changed(self, widget):
  421.         if self.writeSystemDefaultLang():
  422.             gdmscript = '/etc/init.d/gdm'
  423.             if os.path.exists('/var/run/gdm.pid') and os.path.exists(gdmscript):
  424.                 self.runAsRoot([
  425.                     'invoke-rc.d',
  426.                     'gdm',
  427.                     'reload'])
  428.             
  429.         
  430.         self.updateSystemDefaultCombo()
  431.         if self.checkbutton_sync_languages.get_active() == True:
  432.             self.combobox_user_language.set_active(self.combobox_system_language.get_active())
  433.             self.updateUserDefaultCombo()
  434.         
  435.  
  436.     on_combobox_system_language_changed = honorBlockedSignals(insensitive(on_combobox_system_language_changed))
  437.     
  438.     def on_combobox_user_language_changed(self, widget):
  439.         self.check_input_methods()
  440.         self.writeUserDefaultLang()
  441.         self.updateUserDefaultCombo()
  442.         if self.checkbutton_sync_languages.get_active() == True:
  443.             self.combobox_system_language.set_active(self.combobox_user_language.get_active())
  444.             self.updateSystemDefaultCombo()
  445.         
  446.  
  447.     on_combobox_user_language_changed = honorBlockedSignals(insensitive(on_combobox_user_language_changed))
  448.     
  449.     def check_input_methods(self):
  450.         ''' check if the selected langauge has input method support
  451.             and set checkbutton_enable_input_methods accordingly
  452.         '''
  453.         if not self.imSwitch.available():
  454.             return None
  455.         combo = self.combobox_user_language
  456.         model = combo.get_model()
  457.         if combo.get_active() < 0:
  458.             return None
  459.         (lang, code) = model[combo.get_active()]
  460.         active = self.imSwitch.enabledForLocale(code)
  461.         self.checkbutton_enable_input_methods.set_active(active)
  462.  
  463.     check_input_methods = blockSignals(check_input_methods)
  464.     
  465.     def writeInputMethodConfig(self):
  466.         ''' 
  467.         write new input method defaults - currently we only support all_ALL
  468.         '''
  469.         combo = self.combobox_user_language
  470.         model = combo.get_model()
  471.         if combo.get_active() < 0:
  472.             return None
  473.         (lang, code) = model[combo.get_active()]
  474.         new_value = self.checkbutton_enable_input_methods.get_active()
  475.         if self.imSwitch.enabledForLocale(code) != new_value:
  476.             if new_value:
  477.                 self.imSwitch.enable(code)
  478.             else:
  479.                 self.imSwitch.disable(code)
  480.         
  481.  
  482.     
  483.     def on_checkbutton_enable_input_methods_toggled(self, widget):
  484.         active = self.checkbutton_enable_input_methods.get_active()
  485.         self.combo_userlang_dirty = True
  486.         self.setSensitive(False)
  487.         self.writeInputMethodConfig()
  488.         self.setSensitive(True)
  489.  
  490.     on_checkbutton_enable_input_methods_toggled = honorBlockedSignals(on_checkbutton_enable_input_methods_toggled)
  491.     
  492.     def on_checkbutton_sync_languages_toggled(self, widget):
  493.         if self.checkbutton_sync_languages.get_active() == True:
  494.             self.combobox_user_language.set_active(self.combobox_system_language.get_active())
  495.             self.updateSystemDefaultCombo()
  496.         
  497.  
  498.     on_checkbutton_sync_languages_toggled = honorBlockedSignals(on_checkbutton_sync_languages_toggled)
  499.     
  500.     def build_commit_lists(self):
  501.         for lang, langInfo in self._langlist:
  502.             self._cache.tryChangeDetails(langInfo)
  503.         
  504.         (to_inst, to_rm) = self._cache.getChangesList()
  505.         return (to_inst, to_rm)
  506.  
  507.     
  508.     def verify_commit_lists(self, inst_list, rm_list):
  509.         ''' verify if the selected package can actually be installed '''
  510.         res = True
  511.         
  512.         try:
  513.             for pkg in inst_list:
  514.                 if self._cache.has_key(pkg):
  515.                     self._cache[pkg].markInstall()
  516.                     continue
  517.             
  518.             for pkg in rm_list:
  519.                 if self._cache.has_key(pkg):
  520.                     self._cache[pkg].markDelete()
  521.                     continue
  522.         except SystemError:
  523.             res = False
  524.  
  525.         self._cache.clear()
  526.         if self._cache._depcache.BrokenCount != 0:
  527.             d = gtk.MessageDialog(parent = self.window_main, flags = gtk.DIALOG_MODAL, type = gtk.MESSAGE_ERROR, buttons = gtk.BUTTONS_CLOSE)
  528.             d.set_markup('<big><b>%s</b></big>\n\n%s' % (_('Could not install the selected language support'), _("This is perhaps a bug of this application. Please file a bug report at https://launchpad.net/bugs/bugs/+package/ against the 'language-selector' product.")))
  529.             d.set_title = ''
  530.             res = d.run()
  531.             d.destroy()
  532.             progress = GtkProgress(self.dialog_progress, self.progressbar_cache, self.window_main)
  533.             self._cache = apt.Cache(self._localeinfo, progress)
  534.             progress.hide()
  535.             res = False
  536.         
  537.         return res
  538.  
  539.     
  540.     def commitAllChanges(self):
  541.         ''' 
  542.         commit helper, builds the commit lists, verifies it
  543.         
  544.         returns the number of install/removed packages
  545.         '''
  546.         self.setSensitive(False)
  547.         (inst_list, rm_list) = self.build_commit_lists()
  548.         if not self.verify_commit_lists(inst_list, rm_list):
  549.             d = gtk.MessageDialog(parent = self.window_main, flags = gtk.DIALOG_MODAL, type = gtk.MESSAGE_ERROR, buttons = gtk.BUTTONS_CLOSE)
  550.             d.set_markup('<big><b>%s</b></big>\n\n%s' % (_('Could not install the full language support'), _('Usually this is related to an error in your software archive or software manager. Check your software preferences in the menu "Adminstration".')))
  551.             d.set_title('')
  552.             d.run()
  553.             d.destroy()
  554.             self.setSensitive(True)
  555.             return 0
  556.         self.commit(inst_list, rm_list)
  557.         if self.writeSystemDefaultLang():
  558.             gdmscript = '/etc/init.d/gdm'
  559.             if os.path.exists('/var/run/gdm.pid') and os.path.exists(gdmscript):
  560.                 self.runAsRoot([
  561.                     'invoke-rc.d',
  562.                     'gdm',
  563.                     'reload'])
  564.             
  565.         
  566.         self.setSensitive(True)
  567.         return len(inst_list) + len(rm_list)
  568.  
  569.     
  570.     def on_button_ok_clicked(self, widget):
  571.         self.commitAllChanges()
  572.         gtk.main_quit()
  573.  
  574.     
  575.     def on_button_apply_clicked(self, widget):
  576.         self.window_installer.hide()
  577.         if self.commitAllChanges() > 0:
  578.             self.updateLanguageView()
  579.         
  580.         self.updateUserDefaultCombo()
  581.         self.updateSystemDefaultCombo()
  582.  
  583.     
  584.     def _run_synaptic(self, lock, inst, rm, id):
  585.         msg = _('The list of available languages on the system has been updated.')
  586.         msg = msg.replace("'", "\\'")
  587.         cmd = [
  588.             'gksu',
  589.             '--desktop',
  590.             '/usr/share/applications/language-selector.desktop',
  591.             '--',
  592.             '/usr/sbin/synaptic',
  593.             '--hide-main-window',
  594.             '--non-interactive',
  595.             '--parent-window-id',
  596.             '%s' % id,
  597.             '--finish-str',
  598.             msg]
  599.         f = tempfile.NamedTemporaryFile()
  600.         cmd.append('--set-selections-file')
  601.         cmd.append(f.name)
  602.         for s in inst:
  603.             f.write('%s\tinstall\n' % s)
  604.         
  605.         for s in rm:
  606.             f.write('%s\tdeinstall\n' % s)
  607.         
  608.         f.flush()
  609.         subprocess.call(cmd)
  610.         lock.release()
  611.  
  612.     
  613.     def _run_synaptic_update(self, lock, id):
  614.         cmd = [
  615.             'gksu',
  616.             '--desktop',
  617.             '/usr/share/applications/language-selector.desktop',
  618.             '--',
  619.             '/usr/sbin/synaptic',
  620.             '--hide-main-window',
  621.             '--parent-window-id',
  622.             '%s' % id,
  623.             '--non-interactive',
  624.             '--update-at-startup']
  625.         subprocess.call(cmd)
  626.         lock.release()
  627.  
  628.     
  629.     def update(self):
  630.         ''' update the package lists via synaptic '''
  631.         lock = thread.allocate_lock()
  632.         lock.acquire()
  633.         t = thread.start_new_thread(self._run_synaptic_update, (lock, self.window_main.window.xid))
  634.         while lock.locked():
  635.             while gtk.events_pending():
  636.                 gtk.main_iteration()
  637.             time.sleep(0.05)
  638.  
  639.     
  640.     def commit(self, inst, rm):
  641.         if len(inst) == 0 and len(rm) == 0:
  642.             return None
  643.         lock = thread.allocate_lock()
  644.         lock.acquire()
  645.         t = thread.start_new_thread(self._run_synaptic, (lock, inst, rm, self.window_main.window.xid))
  646.         while lock.locked():
  647.             while gtk.events_pending():
  648.                 gtk.main_iteration()
  649.                 continue
  650.                 len(rm) == 0
  651.             time.sleep(0.05)
  652.  
  653.     
  654.     def on_button_cancel_clicked(self, widget):
  655.         self.window_installer.hide()
  656.  
  657.     
  658.     def on_delete_event(self, event, data):
  659.         if self.window_main.get_property('sensitive') is False:
  660.             return True
  661.         gtk.main_quit()
  662.  
  663.     
  664.     def verifyInstalledLangPacks(self):
  665.         ''' called at the start to inform about possible missing
  666.             langpacks (e.g. gnome/kde langpack transition)
  667.         '''
  668.         missing = self.getMissingLangPacks()
  669.         if len(missing) > 0:
  670.             d = gtk.MessageDialog(parent = self.window_main, flags = gtk.DIALOG_MODAL, type = gtk.MESSAGE_QUESTION)
  671.             d.set_markup('<big><b>%s</b></big>\n\n%s' % (_('The language support is not installed completely'), _('Some translations or writing aids available for your chosen languages are not installed yet. Do you want to install them now?')))
  672.             d.add_buttons(_('_Remind Me Later'), gtk.RESPONSE_NO, _('_Install'), gtk.RESPONSE_YES)
  673.             d.set_default_response(gtk.RESPONSE_YES)
  674.             d.set_title('')
  675.             expander = gtk.Expander(_('Details'))
  676.             scroll = gtk.ScrolledWindow()
  677.             scroll.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
  678.             textview = gtk.TextView()
  679.             textview.set_cursor_visible(False)
  680.             textview.set_editable(False)
  681.             buf = textview.get_buffer()
  682.             pkgs = ''
  683.             for pkg in missing:
  684.                 pkgs += '%s\n' % pkg
  685.             
  686.             buf.set_text(pkgs)
  687.             buf.place_cursor(buf.get_start_iter())
  688.             expander.add(scroll)
  689.             scroll.add(textview)
  690.             d.vbox.pack_start(expander)
  691.             expander.show_all()
  692.             res = d.run()
  693.             d.destroy()
  694.             if res == gtk.RESPONSE_YES:
  695.                 self.setSensitive(False)
  696.                 self.commit(missing, [])
  697.                 self.updateLanguageView()
  698.                 self.setSensitive(True)
  699.             
  700.         
  701.  
  702.     
  703.     def updateLanguageView(self):
  704.         self._langlist.clear()
  705.         progress = GtkProgress(self.dialog_progress, self.progressbar_cache, self.window_main)
  706.         
  707.         try:
  708.             self.openCache(progress)
  709.             progress.hide()
  710.         except ExceptionPkgCacheBroken:
  711.             d = gtk.MessageDialog(parent = self.window_main, flags = gtk.DIALOG_MODAL, type = gtk.MESSAGE_ERROR, buttons = gtk.BUTTONS_CLOSE)
  712.             d.set_markup('<big><b>%s</b></big>\n\n%s' % (_('Software database is broken'), _('It is impossible to install or remove any software. Please use the package manager "Synaptic" or run "sudo apt-get install -f" in a terminal to fix this issue at first.')))
  713.             d.set_title('')
  714.             d.run()
  715.             d.destroy()
  716.             sys.exit(1)
  717.  
  718.         languageList = self._cache.getLanguageInformation()
  719.         for lang in languageList:
  720.             inconsistent = lang.inconsistent
  721.             installed = lang.fullInstalled
  722.             self._langlist.append([
  723.                 _(lang.language),
  724.                 lang])
  725.         
  726.         self._langlist.set_sort_column_id(LIST_LANG, gtk.SORT_ASCENDING)
  727.         for button in ('checkbutton_basic_translations', 'checkbutton_extra_translations', 'checkbutton_writing_aids', 'checkbutton_input_methods', 'checkbutton_extra', 'checkbutton_fonts'):
  728.             self.block_toggle = True
  729.             getattr(self, button).set_active(False)
  730.             getattr(self, button).set_sensitive(False)
  731.             self.block_toggle = False
  732.         
  733.  
  734.     
  735.     def writeSystemDefaultLang(self):
  736.         combo = self.combobox_system_language
  737.         model = combo.get_model()
  738.         if combo.get_active() < 0:
  739.             return None
  740.         (lang, code) = model[combo.get_active()]
  741.         old_code = self._localeinfo.getDefaultLanguage()
  742.         if old_code == code:
  743.             return False
  744.         self.setSystemDefaultLanguage(code)
  745.         return True
  746.  
  747.     
  748.     def writeUserDefaultLang(self):
  749.         combo = self.combobox_user_language
  750.         model = combo.get_model()
  751.         if combo.get_active() < 0:
  752.             return None
  753.         (lang, code) = model[combo.get_active()]
  754.         temp = self.getUserDefaultLanguage()
  755.         if temp == None:
  756.             old_code = self._localeinfo.getDefaultLanguage()
  757.         else:
  758.             old_code = temp.split('\\.')[0]
  759.         if old_code == code:
  760.             return False
  761.         self.setUserDefaultLanguage(code)
  762.         return True
  763.  
  764.     
  765.     def updateSystemDefaultCombo(self):
  766.         combo = self.combobox_system_language
  767.         cell = combo.get_child().get_cell_renderers()[0]
  768.         cell.set_property('wrap-width', 300)
  769.         cell.set_property('wrap-mode', pango.WRAP_WORD)
  770.         model = combo.get_model()
  771.         model.clear()
  772.         defaultLangName = None
  773.         defaultLangCode = self.getSystemDefaultLanguage()
  774.         if defaultLangCode:
  775.             defaultLangName = self._localeinfo.translate(defaultLangCode)
  776.         
  777.         for i, locale in enumerate(self._localeinfo.generated_locales()):
  778.             iter = model.append()
  779.             model.set(iter, COMBO_LANGUAGE, self._localeinfo.translate(locale), COMBO_CODE, locale)
  780.             if defaultLangName and self._localeinfo.translate(locale) == defaultLangName:
  781.                 combo.set_active(i)
  782.                 continue
  783.         
  784.         self.combo_syslang_dirty = False
  785.         self.check_status()
  786.  
  787.     updateSystemDefaultCombo = blockSignals(updateSystemDefaultCombo)
  788.     
  789.     def updateUserDefaultCombo(self):
  790.         combo = self.combobox_user_language
  791.         cell = combo.get_child().get_cell_renderers()[0]
  792.         cell.set_property('wrap-width', 300)
  793.         cell.set_property('wrap-mode', pango.WRAP_WORD)
  794.         model = combo.get_model()
  795.         model.clear()
  796.         defaultLangName = None
  797.         defaultLangCode = self.getUserDefaultLanguage()
  798.         if defaultLangCode == None:
  799.             defaultLangCode = self.getSystemDefaultLanguage()
  800.         
  801.         if defaultLangCode:
  802.             defaultLangName = self._localeinfo.translate(defaultLangCode)
  803.         
  804.         for i, locale in enumerate(self._localeinfo.generated_locales()):
  805.             iter = model.append()
  806.             model.set(iter, COMBO_LANGUAGE, self._localeinfo.translate(locale), COMBO_CODE, locale)
  807.             if defaultLangName and self._localeinfo.translate(locale) == defaultLangName:
  808.                 combo.set_active(i)
  809.                 continue
  810.         
  811.         self.combo_userlang_dirty = False
  812.         self.check_status()
  813.  
  814.     updateUserDefaultCombo = blockSignals(updateUserDefaultCombo)
  815.     
  816.     def on_treeview_languages_row_activated(self, treeview, path, view_column):
  817.         self.on_toggled(None, str(path[0]))
  818.  
  819.  
  820.